Users of computing devices are often faced with the task of selecting items, from a collection of items, for some operation. For example, the items may be a collection of electronic mail messages, and the task may be to select which messages to delete. As another example, the items may be files and the task may be select which files to move to a particular folder or directory. As yet another example, the items may be purchases listed on an accounts payable statement, and the task may be “accept for payment” the purchases that are legitimate.
Numerous approaches have been developed to assist users in selecting items, from a collection of items, for an operation. For example, to delete an individual email, some systems allow the user simply click on a visual representation of the email, and then press the delete button. In touch-screen systems, users may perform some gesture, such as a swipe-left, on the visual representation of an email to delete it.
Unfortunately, performing operations on individual items can be burdensome and time consuming. For example, an email account may have a “junk” folder that receives hundreds of email items every day. In most situations, users will want to delete every message in the folder. Performing separate “select” and “delete” operations for each email in the junk folder would take an inordinate amount of time. The burden is only slightly reduced in systems that combine the selection-action input and deletion-action input in a single gesture, such as swipe-left.
To avoid the need to perform operations on a per-item basis, most systems support mechanisms for performing batch operations. For example, most email systems allow a user to select all items in a collection with a single user-input action (e.g. the keystroke CTL-A). After all items have been selected, the user need only specify the action user-input of the operation once (e.g. selecting DELETE, dragging the selected items to a folder, etc.) and the action will be performed on all items in the collection.
Unfortunately, it is not always safe to blindly perform a bulk operation on all items in a collection. For example, it is possible that an important email message is buried somewhere within the hundreds of junk email items in the junk folder. Similarly, even when it is likely that all items on an accounts payable statement are legitimate, it would be imprudent to blindly indicate that all items on the accounts payable statement are legitimate without first at least skimming through the items.
Some systems have been designed with user interface mechanisms that allow the selection of a subset of the items in a collection based on the category of the items. For example, an email system may allow users to mark individual messages with a “star” and provide a control for bulk-selecting all starred messages, or all unstarred messages. Similarly, the system may provide a control for bulk-selecting all “read” or all “unread” messages. Unfortunately, the items on which a user wants to perform a bulk action (e.g. delete all junk mail) do not necessarily align with any pre-established category. For example, bulk-deleting all “junk” email may accidentally delete an important email message that was erroneously categorized as “junk”.
In addition to mechanisms for performing bulk-selections based on categories, many user interfaces provide mechanisms for performing arbitrary bulk-selections. For example, in some systems, files are represented by icons. In such systems, a group of files may be selected by pressing a mouse button and, while the button is held down, dragging the mouse diagonally, and then releasing the mouse button. The system forms a selection box, with one corner at the position where the button was pressed down, and an opposite corner at the position where the button was released. Performing this operation selects that items that correspond to all icons that were enclosed by the selection box.
When the selection is among items in an ordered list, other bulk-selection techniques are possible. For example, assume that an email system displays a vertical list of visual indicators that correspond to email messages. The visual indicators may, for example, display the header information (e.g. subject, sender, recipients, etc.) of the corresponding emails. In such systems, a user may enter one form of user-input to designate the start of a selection, and another form of user-input to designate the end of a selection. For example, a user may “click” on the visual indicator of a first email message, and “shift-click” on the visual indicator of a second email message. In response, the system selects the first message, the second message, and all messages between the first message and the second message.
While existing techniques allow arbitrary bulk-selections, the techniques are error prone and inflexible. For example, if a user clicks on a first email message, and then scrolls down hundreds of email messages and clicks on a second email message (without remembering to shift-click), the system will not select the messages between the first message and the second message. Instead, the system will treat the selection of the second email message as the start of a new selection operation. If this happens, the user will have to scroll back up to try to find the first email message, and try the selection operation again.
Another example of the inflexibility of existing arbitrary bulk-selection mechanism is their inability to add new items to an existing group of selected items. For example, assume that a user has selected a set of email messages including a first email message, a second email message, and all messages between the first and second email messages. Once this selection group has been established, most systems only allow additional messages to be added to the selected group one message at a time (e.g. using a CTL-click). Further, if at any point the user accidentally clicks (without holding down the CTL button) on the visual indicator of an item, the entire selection operation must be restarted from scratch.
Bulk-selection is even more complicated in touch-screen interfaces. For example, the start of a bulk-selection operation may involve tapping on the visual indicator of an item. However, the visual indicator of the last item to be selected may not currently be on the screen. Thus, the user will need to scroll the list until the visual indicator of the last item to be selected is visible. Unfortunately, scrolling the list may involve a gesture such as dragging a finger upward or downward on the list of visual indicators. The dragging of the finger may be misinterpreted as selection of a different visual indicator (as opposed to a scroll operation), causing the user to have to restart the item selection operation from scratch.
The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section.